package com.cictec.middleware.core.entity;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

@Table(name = "t_line_station")
public class BusLineStation implements Serializable {

	@Transient
	private String staName;
	@Transient
	private double enterAngle = Double.NaN;	// 进站夹角
	@Transient
	private double leaveAngle = Double.NaN; // 出站夹角
	
	public double getEnterAngle() {
		return enterAngle;
	}

	public void setEnterAngle(double enterAngle) {
		this.enterAngle = enterAngle;
	}

	public double getLeaveAngle() {
		return leaveAngle;
	}

	public void setLeaveAngle(double leaveAngle) {
		this.leaveAngle = leaveAngle;
	}

	/**
	 * 主键
	 */
	@Id
	@Column(name = "ls_uuid")
	private String lsUuid;

	/**
	 * 线路uuid
	 */
	@Column(name = "ls_line_uuid")
	private String lsLineUuid;

	/**
	 * 线路类型 1：上行 2：下行
	 */
	@Column(name = "ls_line_type")
	private String lsLineType;

	/**
	 * 站点uuid
	 */
	@Column(name = "ls_sta_uuid")
	private String lsStaUuid;

	/**
	 * 进站经度
	 */
	@Column(name = "ls_sta_enter_lng")
	private String lsStaEnterLng;

	/**
	 * 进站纬度
	 */
	@Column(name = "ls_sta_enter_lat")
	private String lsStaEnterLat;

	/**
	 * 出站经度
	 */
	@Column(name = "ls_sta_out_lng")
	private String lsStaOutLng;

	/**
	 * 出站纬度
	 */
	@Column(name = "ls_sta_out_lat")
	private String lsStaOutLat;

	/**
	 * 站点经度
	 */
	@Column(name = "ls_sta_lng")
	private String lsStaLng;

	/**
	 * 站点纬度
	 */
	@Column(name = "ls_sta_lat")
	private String lsStaLat;

	/**
	 * 站点序号
	 */
	@Column(name = "ls_sequence")
	private Integer lsSequence;

	/**
	 * 站点限速（公里/小时）
	 */
	@Column(name = "ls_limit_speed")
	private BigDecimal lsLimitSpeed;

	/**
	 * 起始站点到本站的距离（米）
	 */
	@Column(name = "ls_start_to_this_distance")
	private double lsStartToThisDistance;

	/**
	 * 进出站计算常量 格式： k（斜率）， c1（进站常数），c2（出站常数）
	 */
	@Column(name = "ls_sta_range_params")
	private String lsStaRangeParams;

	/**
	 * 直线图上是否显示该站点。0：不显示；1：显示
	 */
	@Column(name = "ls_isdisplay")
	private Integer lsIsdisplay;

	/**
	 * 站点代码，当上下行站点混排时，该字段代表站点在改线路的顺序。ls_sequence只是上行或者下行的顺序
	 */
	@Column(name = "ls_code")
	private Integer lsCode;

	/**
	 * 删除标志 0--正常数据 1--删除数据
	 */
	@Column(name = "ls_delete_flag")
	private String lsDeleteFlag;

	/**
	 * 删除时间
	 */
	@Column(name = "ls_delete_time")
	private Date lsDeleteTime;

	/**
	 * 大站标志 0 -- 普通站点；1--大站
	 */
	@Column(name = "ls_major")
	private Short lsMajor;

	/**
	 * 来自同步库 1 来自别的库 0 正常录入数据
	 */
	@Column(name = "ls_flag")
	private Short lsFlag;

	private static final long serialVersionUID = 1L;

	/**
	 * 获取主键
	 *
	 * @return ls_uuid - 主键
	 */
	public String getLsUuid() {
		return lsUuid;
	}

	/**
	 * 设置主键
	 *
	 * @param lsUuid
	 *            主键
	 */
	public void setLsUuid(String lsUuid) {
		this.lsUuid = lsUuid == null ? null : lsUuid.trim();
	}

	/**
	 * 获取线路uuid
	 *
	 * @return ls_line_uuid - 线路uuid
	 */
	public String getLsLineUuid() {
		return lsLineUuid;
	}

	/**
	 * 设置线路uuid
	 *
	 * @param lsLineUuid
	 *            线路uuid
	 */
	public void setLsLineUuid(String lsLineUuid) {
		this.lsLineUuid = lsLineUuid == null ? null : lsLineUuid.trim();
	}

	/**
	 * 获取线路类型 1：上行 2：下行
	 *
	 * @return ls_line_type - 线路类型 1：上行 2：下行
	 */
	public String getLsLineType() {
		return lsLineType;
	}

	/**
	 * 设置线路类型 1：上行 2：下行
	 *
	 * @param lsLineType
	 *            线路类型 1：上行 2：下行
	 */
	public void setLsLineType(String lsLineType) {
		this.lsLineType = lsLineType == null ? null : lsLineType.trim();
	}

	/**
	 * 获取站点uuid
	 *
	 * @return ls_sta_uuid - 站点uuid
	 */
	public String getLsStaUuid() {
		return lsStaUuid;
	}

	/**
	 * 设置站点uuid
	 *
	 * @param lsStaUuid
	 *            站点uuid
	 */
	public void setLsStaUuid(String lsStaUuid) {
		this.lsStaUuid = lsStaUuid == null ? null : lsStaUuid.trim();
	}

	/**
	 * 获取进站经度
	 *
	 * @return ls_sta_enter_lng - 进站经度
	 */
	public String getLsStaEnterLng() {
		return lsStaEnterLng;
	}

	/**
	 * 设置进站经度
	 *
	 * @param lsStaEnterLng
	 *            进站经度
	 */
	public void setLsStaEnterLng(String lsStaEnterLng) {
		this.lsStaEnterLng = lsStaEnterLng == null ? null : lsStaEnterLng.trim();
	}

	/**
	 * 获取进站纬度
	 *
	 * @return ls_sta_enter_lat - 进站纬度
	 */
	public String getLsStaEnterLat() {
		return lsStaEnterLat;
	}

	/**
	 * 设置进站纬度
	 *
	 * @param lsStaEnterLat
	 *            进站纬度
	 */
	public void setLsStaEnterLat(String lsStaEnterLat) {
		this.lsStaEnterLat = lsStaEnterLat == null ? null : lsStaEnterLat.trim();
	}

	/**
	 * 获取出站经度
	 *
	 * @return ls_sta_out_lng - 出站经度
	 */
	public String getLsStaOutLng() {
		return lsStaOutLng;
	}

	/**
	 * 设置出站经度
	 *
	 * @param lsStaOutLng
	 *            出站经度
	 */
	public void setLsStaOutLng(String lsStaOutLng) {
		this.lsStaOutLng = lsStaOutLng == null ? null : lsStaOutLng.trim();
	}

	/**
	 * 获取出站纬度
	 *
	 * @return ls_sta_out_lat - 出站纬度
	 */
	public String getLsStaOutLat() {
		return lsStaOutLat;
	}

	/**
	 * 设置出站纬度
	 *
	 * @param lsStaOutLat
	 *            出站纬度
	 */
	public void setLsStaOutLat(String lsStaOutLat) {
		this.lsStaOutLat = lsStaOutLat == null ? null : lsStaOutLat.trim();
	}

	/**
	 * 获取站点经度
	 *
	 * @return ls_sta_lng - 站点经度
	 */
	public String getLsStaLng() {
		return lsStaLng;
	}

	/**
	 * 设置站点经度
	 *
	 * @param lsStaLng
	 *            站点经度
	 */
	public void setLsStaLng(String lsStaLng) {
		this.lsStaLng = lsStaLng == null ? null : lsStaLng.trim();
	}

	/**
	 * 获取站点纬度
	 *
	 * @return ls_sta_lat - 站点纬度
	 */
	public String getLsStaLat() {
		return lsStaLat;
	}

	/**
	 * 设置站点纬度
	 *
	 * @param lsStaLat
	 *            站点纬度
	 */
	public void setLsStaLat(String lsStaLat) {
		this.lsStaLat = lsStaLat == null ? null : lsStaLat.trim();
	}

	/**
	 * 获取站点序号
	 *
	 * @return ls_sequence - 站点序号
	 */
	public Integer getLsSequence() {
		return lsSequence;
	}

	/**
	 * 设置站点序号
	 *
	 * @param lsSequence
	 *            站点序号
	 */
	public void setLsSequence(Integer lsSequence) {
		this.lsSequence = lsSequence;
	}

	/**
	 * 获取站点限速（公里/小时）
	 *
	 * @return ls_limit_speed - 站点限速（公里/小时）
	 */
	public BigDecimal getLsLimitSpeed() {
		return lsLimitSpeed;
	}

	/**
	 * 设置站点限速（公里/小时）
	 *
	 * @param lsLimitSpeed
	 *            站点限速（公里/小时）
	 */
	public void setLsLimitSpeed(BigDecimal lsLimitSpeed) {
		this.lsLimitSpeed = lsLimitSpeed;
	}

	/**
	 * 获取起始站点到本站的距离（米）
	 *
	 * @return ls_start_to_this_distance - 起始站点到本站的距离（米）
	 */
	public double getLsStartToThisDistance() {
		return lsStartToThisDistance;
	}

	/**
	 * 设置起始站点到本站的距离（米）
	 *
	 * @param lsStartToThisDistance
	 *            起始站点到本站的距离（米）
	 */
	public void setLsStartToThisDistance(double lsStartToThisDistance) {
		this.lsStartToThisDistance = lsStartToThisDistance;
	}

	/**
	 * 获取进出站计算常量 格式： k（斜率）， c1（进站常数），c2（出站常数）
	 *
	 * @return ls_sta_range_params - 进出站计算常量 格式： k（斜率）， c1（进站常数），c2（出站常数）
	 */
	public String getLsStaRangeParams() {
		return lsStaRangeParams;
	}

	/**
	 * 设置进出站计算常量 格式： k（斜率）， c1（进站常数），c2（出站常数）
	 *
	 * @param lsStaRangeParams
	 *            进出站计算常量 格式： k（斜率）， c1（进站常数），c2（出站常数）
	 */
	public void setLsStaRangeParams(String lsStaRangeParams) {
		this.lsStaRangeParams = lsStaRangeParams == null ? null : lsStaRangeParams.trim();
	}

	/**
	 * 获取直线图上是否显示该站点。0：不显示；1：显示
	 *
	 * @return ls_isdisplay - 直线图上是否显示该站点。0：不显示；1：显示
	 */
	public Integer getLsIsdisplay() {
		return lsIsdisplay;
	}

	/**
	 * 设置直线图上是否显示该站点。0：不显示；1：显示
	 *
	 * @param lsIsdisplay
	 *            直线图上是否显示该站点。0：不显示；1：显示
	 */
	public void setLsIsdisplay(Integer lsIsdisplay) {
		this.lsIsdisplay = lsIsdisplay;
	}

	/**
	 * 获取站点代码，当上下行站点混排时，该字段代表站点在改线路的顺序。ls_sequence只是上行或者下行的顺序
	 *
	 * @return ls_code - 站点代码，当上下行站点混排时，该字段代表站点在改线路的顺序。ls_sequence只是上行或者下行的顺序
	 */
	public Integer getLsCode() {
		return lsCode;
	}

	/**
	 * 设置站点代码，当上下行站点混排时，该字段代表站点在改线路的顺序。ls_sequence只是上行或者下行的顺序
	 *
	 * @param lsCode
	 *            站点代码，当上下行站点混排时，该字段代表站点在改线路的顺序。ls_sequence只是上行或者下行的顺序
	 */
	public void setLsCode(Integer lsCode) {
		this.lsCode = lsCode;
	}

	/**
	 * 获取删除标志 0--正常数据 1--删除数据
	 *
	 * @return ls_delete_flag - 删除标志 0--正常数据 1--删除数据
	 */
	public String getLsDeleteFlag() {
		return lsDeleteFlag;
	}

	/**
	 * 设置删除标志 0--正常数据 1--删除数据
	 *
	 * @param lsDeleteFlag
	 *            删除标志 0--正常数据 1--删除数据
	 */
	public void setLsDeleteFlag(String lsDeleteFlag) {
		this.lsDeleteFlag = lsDeleteFlag == null ? null : lsDeleteFlag.trim();
	}

	/**
	 * 获取删除时间
	 *
	 * @return ls_delete_time - 删除时间
	 */
	public Date getLsDeleteTime() {
		return lsDeleteTime;
	}

	/**
	 * 设置删除时间
	 *
	 * @param lsDeleteTime
	 *            删除时间
	 */
	public void setLsDeleteTime(Date lsDeleteTime) {
		this.lsDeleteTime = lsDeleteTime;
	}

	/**
	 * 获取大站标志 0 -- 普通站点；1--大站
	 *
	 * @return ls_major - 大站标志 0 -- 普通站点；1--大站
	 */
	public Short getLsMajor() {
		return lsMajor;
	}

	/**
	 * 设置大站标志 0 -- 普通站点；1--大站
	 *
	 * @param lsMajor
	 *            大站标志 0 -- 普通站点；1--大站
	 */
	public void setLsMajor(Short lsMajor) {
		this.lsMajor = lsMajor;
	}

	/**
	 * 获取来自同步库 1 来自别的库 0 正常录入数据
	 *
	 * @return ls_flag - 来自同步库 1 来自别的库 0 正常录入数据
	 */
	public Short getLsFlag() {
		return lsFlag;
	}

	/**
	 * 设置来自同步库 1 来自别的库 0 正常录入数据
	 *
	 * @param lsFlag
	 *            来自同步库 1 来自别的库 0 正常录入数据
	 */
	public void setLsFlag(Short lsFlag) {
		this.lsFlag = lsFlag;
	}


	public String getStaName() {
		return staName;
	}

	public void setStaName(String staName) {
		this.staName = staName;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(getClass().getSimpleName());
		sb.append(" [");
		sb.append("Hash = ").append(hashCode());
		sb.append(", lsUuid=").append(lsUuid);
		sb.append(", lsLineUuid=").append(lsLineUuid);
		sb.append(", lsLineType=").append(lsLineType);
		sb.append(", lsStaUuid=").append(lsStaUuid);
		sb.append(", lsStaEnterLng=").append(lsStaEnterLng);
		sb.append(", lsStaEnterLat=").append(lsStaEnterLat);
		sb.append(", lsStaOutLng=").append(lsStaOutLng);
		sb.append(", lsStaOutLat=").append(lsStaOutLat);
		sb.append(", lsStaLng=").append(lsStaLng);
		sb.append(", lsStaLat=").append(lsStaLat);
		sb.append(", lsSequence=").append(lsSequence);
		sb.append(", lsLimitSpeed=").append(lsLimitSpeed);
		sb.append(", lsStartToThisDistance=").append(lsStartToThisDistance);
		sb.append(", lsStaRangeParams=").append(lsStaRangeParams);
		sb.append(", lsIsdisplay=").append(lsIsdisplay);
		sb.append(", lsCode=").append(lsCode);
		sb.append(", lsDeleteFlag=").append(lsDeleteFlag);
		sb.append(", lsDeleteTime=").append(lsDeleteTime);
		sb.append(", lsMajor=").append(lsMajor);
		sb.append(", lsFlag=").append(lsFlag);
		sb.append("]");
		return sb.toString();
	}
}